package com.xiaobias.stuy;

import java.util.*;
import java.util.stream.Collectors;

/**
 * lambda 学习
 * @author lw
 * @since 2023/6/19-21:33
 */
public class Lambda {
    public static void main(String[] args) {
        // 1. 使用 lambda 表达式进行集合遍历
        List<String> list1 = Arrays.asList("apple", "banana", "orange");
//      使用普通的for增强循环
//        for (String fruit : list1) {
//            System.out.println(fruit);
//        }
        //list1.forEach(fruit -> System.out.println(fruit));// 使用lambda表达式打印输出，有方法体
        list1.forEach(System.out::println);// 使用lambda表达式打印输出

        // 2. 使用 lambda 表达式进行排序
        List<String> list2 = Arrays.asList("apple", "banana", "orange");
//        Collections.sort(list2, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.compareTo(o2);
//            }
//        });
        //Collections.sort(list2, (o1, o2) -> o1.compareTo(o2));// 有方法体
        Collections.sort(list2, String::compareTo);

        // 3. 使用 lambda 表达式进行过滤
        List<String> list3 = Arrays.asList("apple", "banana", "orange");
        List<String> filters = new ArrayList<>();
//        for (String fruit : list3) {// 使用增强for循环进行过滤操作
//            if (fruit.startsWith("a")) {
//                filters.add(fruit);
//            }
//        }
        filters = list3.stream().filter(fruit -> fruit.startsWith("a")).collect(Collectors.toList());

        // 4. 使用 lambda 表达式进行映射
        List<String> list4 = Arrays.asList("apple", "banana", "orange");
        List<Integer> lengths = new ArrayList<>();
//        for (String fruit : list4) {// 使用增强for循环进行遍历
//            lengths.add(fruit.length());
//        }
//        lengths = list4.stream().map(fruit -> fruit.length())// 有方法体的lambda表达式
//                .collect(Collectors.toList());
        lengths = list4.stream().map(String::length)
                .collect(Collectors.toList());

        // 5. 使用lambda 表达式进行归约
        List<Integer> list5 = Arrays.asList(1, 2, 3, 4, 5);
        int sum = 0;
//        for (Integer i : list5) {// 使用lambda表达式进行遍历
//            sum += i;
//        }
        sum = list5.stream().reduce(0, Integer::sum);

        // 6. 使用 lambda表达式进行分组
        List<String> list6 = Arrays.asList("apple", "banana", "orange");
        Map<Integer, List<String>> grouped = new HashMap<>();
//        for (String fruit : list6) {//使用增强for循环进行遍历
//            int length = fruit.length();
//            if (!grouped.containsKey(length)) {
//                grouped.put(length, new ArrayList<>());
//            }
//            grouped.get(length).add(fruit);
//        }
        grouped = list6.stream().collect(Collectors.groupingBy(String::length));

        // 7. 使用 lambda 表达式进行函数是接口的实现
//        MyInterface myObject = new MyInterface() {
//            @Override
//            public void doSomething(String input) {
//                System.out.println(input);
//            }
//        };
        MyInterface myObject = System.out::println;
        myObject.doSomething("Hello World");

//        // 使用lambda表达式进行线程的创建
//        Thread thread = new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("Thread is running.");
//            }
//        });
//        thread.start();
        Thread thread = new Thread(() -> System.out.println("Thread is running."));
        thread.start();

        // 9. 使用lambda表达式进行Optional的操作
//        String str = "Hello World";
//        if (str != null) {
//            System.out.println(str.toUpperCase());
//        }
        Optional<String> strs = Optional.of("Hello World");
        strs.map(String::toUpperCase).ifPresent(System.out::println);

        // 10. 使用lambda表达式进行Stream的流水线操作
        List<String> list10 = Arrays.asList("apple", "banana", "orange");
        List<String> filteredList = new ArrayList<>();
//        for (String fruit : list10) {// 使用增强for循环进行遍历
//            if (fruit.startsWith("a")) {
//                filteredList.add(fruit.toUpperCase());
//            }
//        }
//        Collections.sort(filteredList);
        filteredList = list10.stream().filter(fruit -> fruit.startsWith("a")) .map(String::toUpperCase)
                .sorted()
                .collect(Collectors.toList());
        

    }
}

interface MyInterface {
    void doSomething(String input);
}
